package Execute.MiniSQL;

import Execute.MiniSQL.module.*;
import com.sun.tools.javac.Main;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.util.*;

/*
* 程序调用数据库管理系统时可以获取相关信息，用于后续的处理
* 1、show tables
* 2、create table XXX(colA int, colB decimal, colC varchar(20))
* 3、desc XXX
* 4、drop table XXX
* 5、insert into XXX values(v1, v2, v3)
* 6、update XXX set columnA=25 where columnB='abc'
* 7、
* */

public class TableManager {

    public static String DATA_PATH;     // 数据存储路径
    public static String OPERATORS;          // 操作符
    public static String LOG_PATH;      // 操作日志存储路径
    private static File logtxt;         // 操作日志文件 log.txt
    public static File tableInfo;       // 数据表文件TableInfo.ti
    public static List<String> tableNameStr;   // 存储数据表名称，刚启动时读入，每次创建、删除数据表更新

    private static void readDbHome() {
        System.out.println("readDbHome");
        String currentRunning = System.getProperty("user.dir");
        System.out.println("当前运行目录："+currentRunning);

        Properties properties = new Properties();
        try {
            properties.load(new FileInputStream("Config.properties"));
            // 数据存储（没有则创建
            DATA_PATH = properties.getProperty("dbHome");   // 数据存储路径
            OPERATORS = properties.getProperty("operators");// 操作符
            // 没有则创建对应文件夹
            File midbDir = new File(DATA_PATH);
            if(!midbDir.exists()){
                midbDir.mkdirs();
                System.out.println("创建了数据文件存放的文件夹MiniDatabaseHome");
            }

            // 操作日志（没有则创建
            LOG_PATH = "logs/log.txt";
            logtxt = new File(LOG_PATH);
            if(!logtxt.getParentFile().exists()){
                logtxt.getParentFile().mkdirs();
                System.out.println("创建日志文件夹");
            }
            if(!logtxt.exists()){
                logtxt.createNewFile();
                System.out.println("创建日志文件log.txt");
            }
            recordSystemLogs("启动数据库。");

            // 数据表文件(没有则创建
            tableInfo = new File("TableInfo.ti");
            if (!tableInfo.exists()) {
                tableInfo.createNewFile();
                System.out.println("创建数据表结构信息文件。");
            }

            tableNameStr = new ArrayList<>();
            preShow("show tables");

        }catch (Exception e){
            e.printStackTrace();
        }
    }//readDbHome()


    public TableManager(){
        readDbHome();
    }

    /*
    * 与用户交互时返回操作结果
    * 接收sql语句并根据内容分配给相应功能模块
    * 根据sql语句开头判断操作类型
    * */
    public static SqlResult operate(String sql) {
        sql = sql.replaceAll("string", "varchar(100)");
        sql = sql.replaceAll("float", "decimal");
        SqlResult sqlResult = new SqlResult();
        //Add code
        // 去掉用户输入sql语句开头和结尾的空格
        String s = sql.trim();
//        System.out.println("s: " + s);
        if(s.toLowerCase().startsWith("create")){

            // 对语句进行预处理
            Create create = preCreate(s);
            // 记录系统日志
            recordSystemLogs(sql);

        } else if(s.toLowerCase().startsWith("insert")) {

            // 对语句进行预处理
            Insert insert = preInsert(s);
            // 记录系统日志
            recordSystemLogs(sql);

        } else if(s.toLowerCase().startsWith("delete")) {
            // 对语句进行预处理
            Delete delete = preDelete(s);
            if(delete != null) sqlResult = delete.sqlResult;
            // 记录系统日志
            recordSystemLogs(sql);

        } else if(s.toLowerCase().startsWith("update")) {
            // 对语句进行预处理
            Update update = preUpdate(s);
            if(update != null) sqlResult = update.sqlResult;

            // 记录系统日志
            recordSystemLogs(sql);

        } else if(s.toLowerCase().startsWith("select")) {
            // 对语句进行预处理
            Select select = preSelect(s);
            if(select != null) sqlResult = select.sqlResult;
            // 记录系统日志
            recordSystemLogs(sql);

        } else if(s.toLowerCase().startsWith("show")) {

            // show tables;
            // 对语句进行预处理
            if(preShow(s))
                outPutTableName();
            // 记录系统日志
            recordSystemLogs(sql);

        } else if(s.toLowerCase().startsWith("drop")) {

            // drop tables;
            // 对于语句进行预处理
            preDrop(s);

            // 记录系统日志
            recordSystemLogs(sql);
        } else if(s.toLowerCase().startsWith("desc")) {

            // desc XXX;
            // 对语句进行预处理

            // 去除desc
            s = s.substring(s.indexOf(" ")+1);
            // s = "_XXX_;"
            // 去除分号
            if (s.endsWith(";"))
                s = s.substring(0, s.length()-1);
            s = s.trim();   // sql = "XXX"
            // 获取描述表结构的字符串。输出
            String structure = preDesc(s);
            if (structure != null)
                outputTableStruct(structure);
            else {
                System.out.println("不存在的数据表！");
            }
            // 记录系统日志
            recordSystemLogs(sql);
        } else if(s.toLowerCase().startsWith("help")) {
            String s1 = s.replaceAll("\\s+", "");
            if (s1.endsWith(";")) {
                s1 = s1.substring(0, s1.length()-1);
            }
            if (s1.equalsIgnoreCase("help"))
                showHelp();
            else {
                System.out.println(s + ": 不能识别的指令，或许您想输入的是 `help`? ");
            }
            recordSystemLogs(sql);
        } else if (s.trim().toLowerCase().equals("quit")) {
            recordSystemLogs("退出数据库。");
            System.out.println("miDB>您已退出！");
            sqlResult.sqlFeedBack = "quit";
        }
        else{
            // 不能识别该指令，请检查
            System.out.println("不能识别该指令，请检查");
        }

        return sqlResult;
    }

    /*
    * Select语句预处理
    * sql = "select colA_,_colB from XXX where colC_?_x_,_colD_?_x order by colC desc_;"
    * */
    public static Select preSelect(String sql) {
        sql = sql.replaceAll("\\s+", " ");
        sql = sql.trim();
        // 有分号则去除
        if (sql.endsWith(";")) {
            sql = sql.substring(0, sql.length()-1).trim();      // sql = "colA_,_colB from XXX where colC_?_x_,_colD_?_x order by colC desc"
        }
        // 去除select
        sql = sql.substring(sql.indexOf(" ")+1);        // sql = "colA_,_colB from XXX where colC_?_x_,_colD_?_x order by colC desc_;"
        String tableName;
        // 提取表名，判断表名是否存在
        try {
            if(sql.toLowerCase().contains("where"))
                tableName = sql.substring(sql.toLowerCase().indexOf("from ")+5, sql.indexOf("where")-1);
            else
                tableName = sql.substring(sql.toLowerCase().indexOf("from ")+5);
        } catch (Exception e) {
            System.out.println("不能识别的指令，请检查。");
            return null;
        }
        // 检测表名是否存在
        boolean flag = false;
        for(String k: tableNameStr) {
            if(tableName.equalsIgnoreCase(k)){
                tableName = k;
                flag = true;
            }
        }
        if(!flag) {
            System.out.println(tableName + ".midb：数据表不存在！");
            return null;
        }

        return new Select(tableName, sql);
    }


    /*
    * Update语句预处理
    * sql = "update XXX set columnA_=_25 where columnB_=_'abc'_,_colC_>_12_;"
    * */
    public static Update preUpdate(String sql) {
        sql = sql.replaceAll("\\s+", " ");
        // 去除update
        sql = sql.substring(sql.indexOf(" ")+1).trim();        // sql = "XXX set colA_=_25 where columnB_=_'abc'_,_colC_>_12_;"
        String tableName = null;
        // 提取表名
        try {
            tableName = sql.substring(0, sql.indexOf(" "));
        }catch (Exception e) {
            System.out.println("不能识别的指令，请检查。");
            return null;
        }
        // 检测表名是否存在
        boolean flag = false;
        for(String k: tableNameStr) {
            if(tableName.equalsIgnoreCase(k)){
                tableName = k;
                flag = true;
            }
        }
        if(flag) {
            // 表名存在
            // 去除表名
            sql = sql.substring(sql.indexOf(" ")+1);        // sql = "set colA_=_25 where columnB_=_'abc'_,_colC_>_12_;"
            // 检测set输入是否合法
            String checkset = sql.substring(0, sql.indexOf(" "));
            if(checkset.equalsIgnoreCase("set")) {
                // 输入合法，继续
                // 去除set
                sql = sql.substring(sql.indexOf(" ")+1);
                // 有分号则去除，去除首尾空格
                if(sql.endsWith(";")) {
                    sql = sql.substring(0, sql.length()-1).trim();     // sql = "colA_=_25,_colB_=_'2' where columnB_=_'abc'_,_colC_>_12"
                }
            } else {
                System.out.println(checkset + ": 请检查您的输入，或许您想输入的是 'set' ? ");
                return null;
            }

        } else {
            System.out.println(tableName + ".midb：数据表不存在！");
            return null;
        }

        return new Update(tableName, sql);
    }

    /*
    * Create语句预处理。
    * 1、将多个连续空格替换为单个
    * 2、去除末尾的分号
    * 3、去除开头结尾的空格
    * 提取语句信息
    * */
    public static Create preCreate(String sql) {
        sql = sql.replaceAll("\\s+", " ");
        if (sql.endsWith(";"))
            sql = sql.substring(0, sql.length()-1);
        sql = sql.trim();

        // 经过上述处理，现在得到的语句就是"create table XXX_(_colA int_,_colB decimal_,_colC varchar(_20_)_)"（如果用户未输入空格，相应地方就没有空格，'_'表示可能有空格，可能会有字母大写

        // create一定是拼写对的，到这一步table可能会拼写有误
        // 根据输入规则，create 、 table 、 XXX之间是有空格的，可以据此检测table是否输入正确
        sql = sql.substring(sql.indexOf(" ")+1);    // 去除"create "
        String checkTable = sql.substring(0, sql.indexOf(" "));
        if (!checkTable.equalsIgnoreCase("table")) {
            System.out.println(checkTable + ": 请检查您的输入，或许您想输入的是 'table' ? ");
            return null;
        }

        // table输入无误，去除
        sql = sql.substring(sql.indexOf(" ")+1);    // "XXX_(colA....)"

        String tableName = sql.substring(0, sql.indexOf("(")).trim();           // 获取到表名
        if(repeat(tableName)) {
            System.out.println("表名称不能重复！");
            return null;
        }

        String contentSql = sql.substring(sql.indexOf("(")+1, sql.length()-1);  // contentSql: "_colA int_,,_colB decimal_,_colC varchar(_20_)_"

        String[] contentValue = contentSql.split(",");
        for(int i = 0; i < contentValue.length; i++) {
            contentValue[i] = contentValue[i].trim();
//            contentValue[i] = contentValue[i].replaceAll(" ","_");
//            System.out.println(contentValue[i]);
        }
        // 现在得到的字符串格式就是 "列名称 数据类型"
        // 用list来存储上述信息
        List<String[]> list = new ArrayList<>();
        for (String s : contentValue) {
            // 去除varchar( 20 ) 括号里的空格
            if(s.contains("varchar")) {
                String s1 = s.substring(s.indexOf("(")+1, s.indexOf(")"));
                String s2 = s1.trim();
                s = s.replaceAll(s1, s2);
            }

            String[] cols = s.split(" ");
            // 判断每列个数是否为两个（列名称、数据类型）
            if (cols.length != 2) {
                System.out.println("列名称或数据类型输入个数有误！" + cols.length);
                return null;
            }

            // 字符数据需要输入一个整数作为长度最大值
            if(cols[1].toLowerCase().contains("varchar")){
                if(cols[1].contains("(") && cols[1].contains(")")) {
                    int len = getVarchar(cols[1]);
                }
                else {
                    System.out.println(cols[0] + " 列：字符型数据必需指定一个最大长度，如varchar(20)");
                    return null;
                }
            }
            list.add(cols);
        }

        // 列名称不能重复
        if(repeat(list)) {
            System.out.println("列名称不能重复！");
            return null;
        }
/*
        for (int i = 0; i < list.size(); i++) {
            String[] a = list.get(i);
            System.out.println(a[0] + " " + a[1]);
        }
        System.out.println(tableName);
 */
        return new Create(tableName, list);

    }

    /*
    * 返回varchar括号中的长度，整数，不是整数则返回-1
    * */
    public static int getVarchar(String s) {
        String s1 = s.substring(s.indexOf("(")+1, s.length()-1).trim();
        try {
            return Integer.parseInt(s1);
        }catch (Exception e){
            System.out.println(s + " 列：为字符型数据指定的最大长度需为整型，如20");
            return -1;
        }
    }

    /*
    * 检测是否有重复
    * 重复返回true
    * 不重复返回false
    * */

    // 创表时判断表名是不是重复
    public static boolean repeat(List<String[]> list) {
        if(list.size() == 1) return false;
        for(int i = 0; i < list.size(); i++) {
            for(int j = i+1; j < list.size(); j++) {
                if(list.get(i)[0].equalsIgnoreCase(list.get(j)[0])) return true;
            }
        }
        return false;
    }

    // 传入表名判断表名是否和现有的重复
    public static boolean repeat(String name) {
        if(tableNameStr.size() == 0) return false;
        else {
            for(int i = 0; i < tableNameStr.size(); i++) {
                if(name.equalsIgnoreCase(tableNameStr.get(i))) {
                    return true;    // 名称重复
                }
            }
        }
        return false;
    }

    /*
    * show tables语句预处理
    * 检测tables输入是否正确，正确则读取TableInfo文件，将数据表名称写入tableNameStr列表(需满足表名不重复，重复则代表以及记录过了)
    * */
    public static boolean preShow(String sql) {
        sql = sql.replaceAll(";","");
        sql = sql.replaceAll("\\s+"," ");
        String[] l = sql.split(" ");
        if(l.length != 2) {
            System.out.println("不能识别该指令，请检查");
            return false;
        }
        else {
            if(l[1].equalsIgnoreCase("tables")) {
                // 执行指令。
                RandomAccessFile raf = null;
                try {
                    raf = new RandomAccessFile(tableInfo, "r");
                    long len = raf.length();
                    if(len != 0L) {
                        byte[] bytes = new byte[(int)len];
                        raf.read(bytes);
                        String content = new String(bytes, StandardCharsets.UTF_8);
                        String[] t = content.split(",");
                        for(String s: t) {
                            String[] tn = s.split(" ");
                            if(!repeat(tn[0]))
                                tableNameStr.add(tn[0]);
                        }
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    if (raf != null) {
                        try {
                            raf.close();
                        }catch (Exception e1){
                            e1.printStackTrace();
                        }
                    }
                }
                return true;
            }else {
                System.out.println(l[1] + ": 请检查您的输入，或许您想输入的是 'tables' ? ");
                return false;
            }
        }
    }

    /*
    * show tables输出语句
    * */
    public static void outPutTableName() {
        System.out.println("数据表");
        for (String s : tableNameStr) {
            System.out.println(s);
        }
        System.out.println("共有 " + tableNameStr.size() + " 个数据表。");
    }

    /*
    * 传过来表名，返回表结构的字符串
    * return "Student id int Height decimal name varchar(20)"
    * */
    public static String preDesc(String name) {
        // 首先确定表名存在
        boolean flag = false;
        for(String t : tableNameStr) {
            if(t.equalsIgnoreCase(name)) {
                flag = true;
                break;
            }
        }
        // 读取TableInfo.ti文件，获取描述表结构的字符串
        if (flag) {
            RandomAccessFile raf = null;
            String strStruct = null;
            try{
                raf = new RandomAccessFile(tableInfo, "r");
                long len = raf.length();
                if(len != 0L) {
                    byte[] bytes = new byte[(int)len];
                    raf.read(bytes);
                    String content = new String(bytes, StandardCharsets.UTF_8);
                    String[] t = content.split(",");
                    for(String s : t) {
                        String[] tn = s.split(" ");
                        if(tn[0].equalsIgnoreCase(name)) {
                            strStruct = s;
                            break;
                        }
                    }
                }
            } catch (Exception e){
                e.printStackTrace();
            } finally {
                if(raf != null) {
                    try {
                        raf.close();
                    }catch (Exception e1){
                        e1.printStackTrace();
                    }
                }
            }
            return strStruct;
        }else {
            return null;
        }
    }

    /*
    * 用于desc XXX输出表结构
    * structure = "XXX colA int colB decimal colC varchar(20)..."
    * */
    public static void outputTableStruct(String structure) {
        String[] t = structure.split(" ");
        System.out.println("列名称, 列类型, 列宽度");
        for(int i = 1; i < t.length; i += 2) {
            System.out.print(t[i] + ", " + t[i+1] + ", ");
            if(t[i+1].equals("int") || t[i+1].equals("decimal")) {
                System.out.println("1");
            }else {
                int len = getVarchar(t[i+1]);
                System.out.println(len);
            }
        }
    }

    /*
    * Insert的预处理
    * sql = "insert into XXX values(v1, v2, v3)_;"
    * */
    public static Insert preInsert(String sql) {
        sql = sql.replaceAll("\\s+", " ");
        // 去除insert
        sql = sql.substring(sql.indexOf(" ")+1);  // sql = "into_XXX_values_(v1, v2, v3)_;"
        // 去除末尾的分号
        if (sql.endsWith(";"))
            sql = sql.substring(0, sql.length()-1).trim();  // sql = "into_XXX_values_(v1, v2, v3)"
        // 输入格式是否正确 into
        String si = sql.substring(0, sql.indexOf(" "));
        String tableName = null;
        if(si.equalsIgnoreCase("into")) {
            // 去除into
            sql = sql.substring(sql.indexOf(" ")+1);    // sql = "XXX_values_(_v1_,_v2_,_v3_)"
            // 提取表名，判断是否存在
            tableName = sql.substring(0, sql.indexOf(" "));
            boolean flag = false;
            for(String k : tableNameStr){
                if(k.equalsIgnoreCase(tableName)) {
                    flag = true;
                    tableName = k;
                }
            }

            if(flag) {
                // 名称重复说明表存在

                // 去除表名
                sql = sql.substring(sql.indexOf(" ")+1);    // sql = "values_(_v1_,_v2_,_'v3'_)"

                // 检测values输入是否正确
                String sv = sql.substring(0, sql.indexOf("(")).trim();
                if(sv.equalsIgnoreCase("values")) {
                    // values输入无误
                    // 去除values、括号
                    try {
                        sql = sql.substring(sql.indexOf("(")+1, sql.indexOf(")")).trim();  // sql = "v1_,_v2_,_'v3'"
                    }catch (Exception e){
                        System.out.println("您的输入有误！请正确输入值并用英文括号包裹。");
                    }
                    return new Insert(tableName, sql);
                }else {
                    // values输入错误
                    System.out.println(sv + ": 请检查您的输入，或许您想输入的是 'values' ? ");
                    return null;
                }

            }else {
                // 不重复说明表不存在
                System.out.println("数据表 " + tableName + " 不存在！");
                return null;
            }
        }else {
            // into输入错误
            System.out.println(si + ": 请检查您的输入，或许您想输入的是 'into' ? ");
            return null;
        }
    }

    /*
    * drop的处理 drop table XXX
    * 检测table输入是否正确，提取表名，存在则删除
    * */
    public static void preDrop(String sql) {
        // 将多个空格替换为单个
        sql = sql.replaceAll("\\s+" , " "); // sql = "drop table XXX_;"
        // 去除drop
        sql = sql.substring(sql.indexOf(" ")+1);
        // 去除末尾分号
        if (sql.endsWith(";")) {
            sql = sql.substring(0, sql.length()-1).trim();
        }
        // sql = "table XXX"
        String t = null;
        try {
            t = sql.substring(0, sql.indexOf(" "));
        }catch (Exception e) {
            System.out.println("不能识别的指令，请检查。");
            return;
        }

        if (t.equalsIgnoreCase("table")) {
            String tableName;
            // 提取表名
            try {
                tableName = sql.substring(sql.indexOf(" ")+1);
            }catch (Exception e) {
                System.out.println("不能识别的指令，请检查。");
                return ;
            }
            boolean flag = false;
            // 检测表名是否存在
            for(int i = 0; i < tableNameStr.size(); i++){
                if(tableNameStr.get(i).equalsIgnoreCase(tableName)) {
                    flag = true;
                    tableName = tableNameStr.get(i);
                    // 更新tableNameStr
                    tableNameStr.remove(i);
                    break;
                }
            }
            if(flag) {
                File database = new File(DATA_PATH + "/" + tableName + ".midb");
                // 删除数据表文件
                database.delete();
                // 删除TableInfo.ti中的表结构信息
                deleteTableInfo(tableName);
            }else {
                System.out.println(tableName + ".midb：请检查您的输入，不存在的数据表文件!");
            }

        } else {
            System.out.println(t + "：请检查您的输入，或许您想输入的是 'table' ? ");
        }
    }

    /*
    * 将要删除的数据表结构信息从TableInfo文件中删除
    * */
    public static void deleteTableInfo(String tableName) {
        try {
            RandomAccessFile raf = new RandomAccessFile(tableInfo, "rw");
            long len = raf.length();
            byte[] bytes = new byte[(int)len];
            raf.read(bytes);
            String content = new String(bytes, StandardCharsets.UTF_8);
            String[] t = content.split(",");
            for(int i = 0; i < t.length; i++) {
                String[] tn = t[i].split(" ");
                if (tn[0].equalsIgnoreCase(tableName)) {
//                    System.out.println("查找到t[i]: " + t[i]);
                    // 删除
//                    System.out.println("content: " + content);
                    content = content.replace(t[i]+",", "");
//                    System.out.println("content: " + content);
                    long length = content.length();
                    // 从头再写入
                    raf.seek(0);
                    raf.setLength(length);
                    raf.write(content.getBytes(StandardCharsets.UTF_8));
                }
            }
            raf.close();
            System.out.println("删除数据表 " + tableName + " 成功！");
        }catch (Exception e) {
            e.printStackTrace();
        }
    }

    /*
    * Delete操作预处理
    * 检测from是否拼写有误，提取表名，提取要求
    * */
    public static Delete preDelete(String sql) {
        // 将语句中多个空格替换为单个
        sql = sql.replaceAll("\\s+", " ");
        // 去除delete
        sql = sql.substring(sql.indexOf(" ")+1);        // sql = "from XXX where colA_<>_2_,_colB_<>_2;"
        // 去除分号
        if(sql.endsWith(";")){
            sql = sql.substring(0, sql.length()-1).trim();     // sql = "from XXX where colA_<>_2,_colB_<>_2"
        }
        String tableName = null;
        // 检查from拼写
        String t = sql.substring(0,sql.indexOf(" "));
        if(t.equalsIgnoreCase("from")){
            // 去除from
            sql = sql.substring(sql.indexOf(" ")+1);        // sql = "XXX where colA_<>_2,_colB_<>_2"
            // 提取表名
            try {
                tableName = sql.substring(0, sql.indexOf(" "));
            }catch (Exception e) {
                System.out.println("不能识别的指令，请检查。");
                return null;
            }

            // 检测表名是否存在
            boolean flag = false;
            for(String k: tableNameStr) {
                if(tableName.equalsIgnoreCase(k)){
                    tableName = k;
                    flag = true;
                }
            }
            if(flag) {
                // 提取条件
                sql = sql.toLowerCase().substring(sql.toLowerCase().indexOf("where ")+6);        // sql = "colA_<>_2_,_colB_>_1"
            } else {
                System.out.println(tableName + ".midb：数据表不存在！");
                return null;
            }
        } else {
            System.out.println(t + "：请检查您的输入，或许您想输入的是 'from' ? ");
            return null;
        }

        return new Delete(tableName, sql);
    }

    /*
    * 记录系统日志
    * */
    public static void recordSystemLogs(String sql) {
        FileOutputStream outputStream = null;
        try {
            outputStream = new FileOutputStream(logtxt, true);
            Date date = new Date();
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd: HH:mm:ss: ");
            String s = dateFormat.format(date) + sql + "\n";
            outputStream.write(s.getBytes());
            outputStream.flush();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(outputStream != null){
                try {
                    outputStream.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }


    public static void showHelp() {
        // 文本块
        String s_help =
                """
                        quit ---- 退出迷你数据库管理系统。
                        help ---- 显示所有的指令。
                        show tables -- 显示目前所有数据表。
                        desc table XXX --- 显示数据表XXX中的表结构。
                        create table XXX(columnA varchar(10), columnB int, columnC decimal) ---- 创建一个3列的名称为XXX的表格，列名称为columnA, columnB, columnC。其类型分别为10个以内的字符、整型数和小数。
                        drop table XXX -- 删除表格XXX。
                        select colX, colY, colZ from XXX where colZ > 1.5 order by colZ desc --- 从数据表XXX中选取3列，colX, colY, colZ, 每一个记录必须满足colZ的值大于1.5，且显示时按照colZ这一列的降序排列。
                        select * from XXX where colA <> '北林信息' ---- 从数据表XXX中选取所有的列，但记录要满足列colA不是北林信息。
                        insert into XXX values('北林信息', 15, 25.5) ---- 向数据表XXX中追加一条记录，各个列的值分别为北林信息、15、25.5。
                        delete from XXX where colB = 10 ---- 把表格XXX中colB列的值是10的记录全部删除。
                        update XXX set colD = '计算机科学与技术' where colA = '北林信息' ---- 在数据表XXX中，把那些colA是北林信息的记录中的colD列全部改写为计算机科学与技术。
                        """;
        System.out.println(s_help);
    }
}
